home *** CD-ROM | disk | FTP | other *** search
/ Aminet 1 / Aminet - June 1993 [Walnut Creek].iso / usenet / sources / volume90 / aplictns / dkbtrace / part06 < prev    next >
Encoding:
Internet Message Format  |  1990-09-03  |  55.6 KB
  1. Path: abcfd20.larc.nasa.gov!amiga-request
  2. From: amiga-request@abcfd20.larc.nasa.gov (Amiga Sources/Binaries Moderator)
  3. Subject: v90i254: DKBTrace 2.01 - DKBtrace Ray-Tracer, Part06/10
  4. Reply-To: David Schanen <mtv@milton.u.washington.edu>
  5. Newsgroups: comp.sources.amiga
  6. Message-ID: <comp.sources.amiga:v90i254@abcfd20.larc.nasa.gov>
  7. References: <comp.sources.amiga:v90i249@abcfd20.larc.nasa.gov>
  8. Date: 03 Sep 90 23:22:15 GMT
  9. Approved: tadguy@uunet.UU.NET (Tad Guy)
  10. X-Mail-Submissions-To: amiga@uunet.uu.net
  11. X-Post-Discussions-To: comp.sys.amiga
  12.  
  13. Submitted-by: David Schanen <mtv@milton.u.washington.edu>
  14. Posting-number: Volume 90, Issue 254
  15. Archive-name: applications/dkbtrace-2.01/part06
  16.  
  17. #!/bin/sh
  18. # This is a shell archive.  Remove anything before this line, then unpack
  19. # it by saving it into a file and typing "sh file".  To overwrite existing
  20. # files, type "sh file -c".  You can also feed this as standard input via
  21. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  22. # will see the following message at the end:
  23. #        "End of archive 6 (of 10)."
  24. # Contents:  src/dkbproto.h src/tokenize.c src/triangle.c
  25. # Wrapped by tadguy@abcfd20 on Mon Sep  3 19:21:20 1990
  26. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  27. if test -f 'src/dkbproto.h' -a "${1}" != "-c" ; then 
  28.   echo shar: Will not clobber existing file \"'src/dkbproto.h'\"
  29. else
  30. echo shar: Extracting \"'src/dkbproto.h'\" \(16900 characters\)
  31. sed "s/^X//" >'src/dkbproto.h' <<'END_OF_FILE'
  32. X/*****************************************************************************
  33. X*
  34. X*                                  dkbproto.h
  35. X*
  36. X*   from DKBTrace (c) 1990  David Buck
  37. X*
  38. X*  This module defines the prototypes for all system-independent functions.
  39. X*
  40. X* This software is freely distributable. The source and/or object code may be
  41. X* copied or uploaded to communications services so long as this notice remains
  42. X* at the top of each file.  If any changes are made to the program, you must
  43. X* clearly indicate in the documentation and in the programs startup message
  44. X* who it was who made the changes. The documentation should also describe what
  45. X* those changes were. This software may not be included in whole or in
  46. X* part into any commercial package without the express written consent of the
  47. X* author.  It may, however, be included in other public domain or freely
  48. X* distributed software so long as the proper credit for the software is given.
  49. X*
  50. X* This software is provided as is without any guarantees or warranty. Although
  51. X* the author has attempted to find and correct any bugs in the software, he
  52. X* is not responsible for any damage caused by the use of the software.  The
  53. X* author is under no obligation to provide service, corrections, or upgrades
  54. X* to this package.
  55. X*
  56. X* Despite all the legal stuff above, if you do find bugs, I would like to hear
  57. X* about them.  Also, if you have any comments or questions, you may contact me
  58. X* at the following address:
  59. X*
  60. X*     David Buck
  61. X*     22C Sonnet Cres.
  62. X*     Nepean Ontario
  63. X*     Canada, K2H 8W7
  64. X*
  65. X*  I can also be reached on the following bulleton boards:
  66. X*
  67. X*     ATX              (613) 526-4141
  68. X*     OMX              (613) 731-3419
  69. X*     Mystic           (613) 731-0088 or (613) 731-6698
  70. X*
  71. X*  Fidonet:   1:163/109.9
  72. X*  Internet:  David_Buck@Carleton.CA
  73. X*
  74. X*  IBM Port by Aaron A. Collins. Aaron may be reached on the following BBS'es:
  75. X*
  76. X*     Lattice BBS                      (708) 916-1200
  77. X*     The Information Exchange BBS     (708) 945-5575
  78. X*     Stillwaters BBS                  (708) 403-2826
  79. X*
  80. X*****************************************************************************/
  81. X
  82. X
  83. X/* Prototypes for functions defined in trace.c */
  84. Xvoid close_all PARAMS((void));
  85. Xvoid get_defaults PARAMS((void));
  86. Xvoid read_options PARAMS((char *file_name));
  87. Xvoid parse_option PARAMS((char *Option_String));
  88. Xvoid parse_file_name PARAMS((char *File_Name));
  89. Xvoid Print_Options PARAMS((void));
  90. Xvoid print_stats PARAMS((void));
  91. X
  92. X/* Prototypes for functions defined in render.c */
  93. Xvoid Create_Ray PARAMS((RAY *ray, int width, int height, DBL x, DBL y));
  94. Xvoid Write_Line PARAMS((COLOUR *Line, int y));
  95. Xvoid Supersample PARAMS((COLOUR *result, int x, int y, int Width, int Height));
  96. Xvoid Start_Tracing PARAMS((void));
  97. Xvoid Trace PARAMS((RAY *Ray, COLOUR *Colour));
  98. X
  99. X/* Prototypes for functions defined in tokenize.c */
  100. Xvoid Tokenize PARAMS((char *name, FILE *in, FILE *symbol, FILE *out));
  101. Xint Process_Token PARAMS((void));
  102. Xint Skip_Spaces PARAMS((void));
  103. Xint Parse_Comments PARAMS((void));
  104. Xvoid Begin_String PARAMS((void));
  105. Xvoid Stuff_Character PARAMS((char c));
  106. Xvoid End_String PARAMS((void));
  107. Xint Read_Float PARAMS((void));
  108. Xint Parse_String PARAMS((void));
  109. Xint Read_Include PARAMS((void));
  110. Xint Read_Symbol PARAMS((void));
  111. Xint Find_Reserved PARAMS((void));
  112. Xint Find_Symbol PARAMS((void));
  113. Xvoid Write_Token PARAMS((enum Token_Type Token_Id));
  114. Xvoid Token_Error PARAMS((char *str));
  115. X
  116. X/* Prototypes for functions defined in parse.c */
  117. Xvoid Parse PARAMS((FILE *File, FRAME *Frame_Ptr));
  118. Xvoid Token_Init PARAMS((void));
  119. Xint Get_Token PARAMS((void));
  120. Xvoid Unget_Token PARAMS((void));
  121. Xvoid Frame_Init PARAMS((void));
  122. XCOMPOSITE *Get_Composite_Object PARAMS((void));
  123. XSPHERE *Get_Sphere_Shape PARAMS((void));
  124. XQUADRIC *Get_Quadric_Shape PARAMS((void));
  125. XPLANE *Get_Plane_Shape PARAMS((void));
  126. XTRIANGLE *Get_Triangle_Shape PARAMS((void));
  127. XSMOOTH_TRIANGLE *Get_Smooth_Triangle_Shape PARAMS((void));
  128. XCSG_SHAPE *Get_CSG_Shape PARAMS((void));
  129. XCSG_SHAPE *Get_CSG_Union PARAMS((void));
  130. XCSG_SHAPE *Get_CSG_Intersection PARAMS((void));
  131. XCSG_SHAPE *Get_CSG_Difference PARAMS((void));
  132. Xvoid Set_CSG_Parents PARAMS((CSG_SHAPE *, OBJECT *));
  133. XOBJECT *Get_Object PARAMS((void));
  134. XTEXTURE *Get_Texture PARAMS((void));
  135. XVIEWPOINT *Get_Viewpoint PARAMS((void));
  136. XCOLOUR *Get_Colour PARAMS((void));
  137. XVECTOR *Get_Vector PARAMS((void));
  138. XDBL *Get_Float PARAMS((void));
  139. XTRANSFORMATION *Get_Transformation PARAMS((void));
  140. XDBL Parse_Float PARAMS((void));
  141. Xvoid Parse_Vector PARAMS((VECTOR *Given_Vector));
  142. Xvoid Parse_Colour PARAMS((COLOUR *Given_Colour));
  143. XCOLOUR_MAP *Parse_Colour_Map PARAMS((void));
  144. XTEXTURE *Copy_Texture PARAMS((TEXTURE *Texture));
  145. XTEXTURE *Parse_Texture PARAMS((TEXTURE *Old_Texture));
  146. XSHAPE *Parse_Sphere PARAMS((void));
  147. XSHAPE *Parse_Plane PARAMS((void));
  148. XSHAPE *Parse_Triangle PARAMS((void));
  149. XSHAPE *Parse_Smooth_Triangle PARAMS((void));
  150. XSHAPE *Parse_Quadric PARAMS((void));
  151. XCSG_SHAPE *Parse_CSG PARAMS((int type, OBJECT *Parent_Object));
  152. XSHAPE *Parse_Shape PARAMS((OBJECT *Object));
  153. XOBJECT *Parse_Object PARAMS((void));
  154. XOBJECT *Parse_Composite PARAMS((void));
  155. Xvoid Parse_Fog PARAMS((void));
  156. Xvoid Parse_Frame PARAMS((void));
  157. Xvoid Parse_Viewpoint PARAMS((VIEWPOINT *Given_Vp));
  158. Xvoid Parse_Declare PARAMS((void));
  159. Xvoid Init_Viewpoint PARAMS((VIEWPOINT *vp));
  160. Xvoid Link PARAMS((OBJECT *New_Object,
  161. X          OBJECT **Field,
  162. X          OBJECT **Old_Object_List));
  163. XCONSTANT Find_Constant PARAMS((void));
  164. Xchar *Get_Token_String PARAMS((TOKEN Token_Id));
  165. Xvoid Parse_Error PARAMS((TOKEN Token_Id));
  166. Xvoid Type_Error PARAMS((void));
  167. Xvoid Undeclared PARAMS((void));
  168. Xvoid Error PARAMS((char *str));
  169. X
  170. X/* Prototypes for functions defined in objects.c */
  171. XINTERSECTION *Object_Intersect PARAMS((OBJECT *Object, RAY *Ray));
  172. Xint All_Composite_Intersections PARAMS((OBJECT *Object, RAY *Ray, PRIOQ *Depth_Queue));
  173. Xint All_Object_Intersections PARAMS((OBJECT *Object, RAY *Ray, PRIOQ *Depth_Queue));
  174. Xint Inside_Basic_Object PARAMS((VECTOR *Point, OBJECT *Object)); 
  175. Xint Inside_Composite_Object PARAMS((VECTOR *Point, OBJECT *Object));
  176. Xvoid *Copy_Basic_Object PARAMS((OBJECT *Object));
  177. Xvoid *Copy_Composite_Object PARAMS((OBJECT *Object));
  178. Xvoid Translate_Basic_Object PARAMS((OBJECT *Object, VECTOR *Vector));
  179. Xvoid Rotate_Basic_Object PARAMS((OBJECT *Object, VECTOR *Vector));
  180. Xvoid Scale_Basic_Object PARAMS((OBJECT *Object, VECTOR *Vector));
  181. Xvoid Translate_Composite_Object PARAMS((OBJECT *Object, VECTOR *Vector));
  182. Xvoid Rotate_Composite_Object PARAMS((OBJECT *Object, VECTOR *Vector));
  183. Xvoid Scale_Composite_Object PARAMS((OBJECT *Object, VECTOR *Vector));
  184. Xvoid Invert_Basic_Object PARAMS((OBJECT *Object));
  185. Xvoid Invert_Composite_Object PARAMS((OBJECT *Object));
  186. X
  187. X/* Prototypes for functions defined in spheres.c */
  188. Xint All_Sphere_Intersections PARAMS((OBJECT *Object, RAY *Ray, PRIOQ *Depth_Queue));
  189. Xint Intersect_Sphere PARAMS((RAY *Ray, SPHERE *Sphere, DBL *Depth1, DBL *Depth2));
  190. Xint Inside_Sphere PARAMS((VECTOR *Point, OBJECT *Object));
  191. Xvoid Sphere_Normal PARAMS((VECTOR *Result, OBJECT *Object, VECTOR *Intersection_Point));
  192. Xvoid *Copy_Sphere PARAMS((OBJECT *Object));
  193. Xvoid Translate_Sphere PARAMS((OBJECT *Object, VECTOR *Vector));
  194. Xvoid Rotate_Sphere PARAMS((OBJECT *Object, VECTOR *Vector));
  195. Xvoid Scale_Sphere PARAMS((OBJECT *Object, VECTOR *Vector));
  196. Xvoid Invert_Sphere PARAMS((OBJECT *Object));
  197. X
  198. X/* Prototypes for functions defined in quadrics.c */
  199. Xint All_Quadric_Intersections PARAMS((OBJECT *Object, RAY *Ray, PRIOQ *Depth_Queue));
  200. Xint Intersect_Quadric PARAMS((RAY *Ray, QUADRIC *Shape, DBL *Depth1, DBL *Depth2));
  201. Xint Inside_Quadric PARAMS((VECTOR *Point, OBJECT *Object));
  202. Xvoid Quadric_Normal PARAMS((VECTOR *Result, OBJECT *Object, VECTOR *Intersection_Point));
  203. Xvoid *Copy_Quadric PARAMS((OBJECT *Object));
  204. Xvoid Transform_Quadric PARAMS((QUADRIC *Shape, TRANSFORMATION *Transformation));
  205. Xvoid Quadric_To_Matrix PARAMS((QUADRIC *Quadric, MATRIX *Matrix));
  206. Xvoid Matrix_To_Quadric PARAMS((MATRIX *Matrix, QUADRIC *Quadric));
  207. Xvoid Translate_Quadric PARAMS((OBJECT *Object, VECTOR *Vector));
  208. Xvoid Rotate_Quadric PARAMS((OBJECT *Object, VECTOR *Vector));
  209. Xvoid Scale_Quadric PARAMS((OBJECT *Object, VECTOR *Vector));
  210. Xvoid Invert_Quadric PARAMS((OBJECT *Object));
  211. X
  212. X/* Prototypes for functions defined in triangle.c */
  213. Xvoid Find_Triangle_Dominant_Axis PARAMS((TRIANGLE *Triangle));
  214. Xint Compute_Triangle  PARAMS((TRIANGLE *Triangle));
  215. Xvoid Compute_Smooth_Triangle  PARAMS((SMOOTH_TRIANGLE *Triangle));
  216. Xint All_Triangle_Intersections  PARAMS((OBJECT *Object, RAY *Ray, PRIOQ *Depth_Queue));
  217. Xint Intersect_Triangle  PARAMS((RAY *Ray, TRIANGLE *Triangle, DBL *Depth));
  218. Xint Inside_Triangle  PARAMS((VECTOR *Point, OBJECT *Object));
  219. Xvoid Triangle_Normal  PARAMS((VECTOR *Result, OBJECT *Object, VECTOR *Intersection_Point));
  220. Xvoid *Copy_Triangle  PARAMS((OBJECT *Object));
  221. Xvoid Translate_Triangle  PARAMS((OBJECT *Object, VECTOR *Vector));
  222. Xvoid Rotate_Triangle  PARAMS((OBJECT *Object, VECTOR *Vector));
  223. Xvoid Scale_Triangle  PARAMS((OBJECT *Object, VECTOR *Vector));
  224. Xvoid Invert_Triangle  PARAMS((OBJECT *Object));
  225. Xvoid Smooth_Triangle_Normal  PARAMS((VECTOR *Result, OBJECT *Object, VECTOR *Intersection_Point));
  226. Xvoid *Copy_Smooth_Triangle PARAMS((OBJECT *Object));
  227. Xvoid Rotate_Smooth_Triangle  PARAMS((OBJECT *Object, VECTOR *Vector));
  228. X
  229. X
  230. X/* Prototypes for functions defined in lighting.c */
  231. Xvoid Colour_At PARAMS((COLOUR *Colour, OBJECT *Object, VECTOR *Intersection_Point));
  232. Xvoid Perturb_Normal PARAMS((VECTOR *New_Normal, OBJECT *Object, VECTOR *Intersection_Point,
  233. X                    VECTOR *Surface_Normal));
  234. Xvoid Ambient PARAMS((OBJECT *Object, VECTOR *Intersection_Point, COLOUR *Surface_Colour,
  235. X             COLOUR *Colour));
  236. Xvoid Diffuse PARAMS((OBJECT *Object, VECTOR *Intersection_Point, RAY *Eye, VECTOR *Surface_Normal,
  237. X             COLOUR *Surface_Colour, COLOUR *Colour));
  238. Xvoid Transmit PARAMS((OBJECT *Object, VECTOR *Intersection_Point, RAY *Ray,
  239. X              VECTOR *Surface_Normal, COLOUR *Surface_Colour, COLOUR *Colour));
  240. Xvoid Reflect PARAMS((OBJECT *Object, VECTOR *Intersection_Point, RAY *Ray, 
  241. X             VECTOR *Surface_Normal, COLOUR *Colour));
  242. Xvoid Refract PARAMS((OBJECT *Object, VECTOR *Intersection_Point, RAY *Ray,
  243. X             VECTOR *Surface_Normal, COLOUR *Colour));
  244. Xvoid Fog PARAMS((DBL Distance, COLOUR *Fog_Colour, DBL Fog_Distance, COLOUR *Colour));
  245. X
  246. X/* Prototypes for functions defined in prioq.c */
  247. Xvoid pq_init PARAMS((void));
  248. XPRIOQ *pq_alloc PARAMS((void));
  249. Xvoid pq_free PARAMS((PRIOQ *pq));
  250. XPRIOQ *pq_new PARAMS((int index_size));
  251. Xvoid pq_balance PARAMS((PRIOQ *q, unsigned int entry_pos1));
  252. Xvoid pq_add PARAMS((PRIOQ *q, INTERSECTION *entry));
  253. XINTERSECTION *pq_get_highest PARAMS((PRIOQ *q));
  254. Xint pq_is_empty PARAMS((PRIOQ *q));
  255. Xvoid pq_delete_highest PARAMS((PRIOQ *q));
  256. X
  257. X/* Prototypes for functions defined in texture.c */
  258. Xvoid Compute_Colour PARAMS((COLOUR *Colour, COLOUR_MAP *Colour_Map, DBL value));
  259. Xvoid Initialize_Noise PARAMS((void));
  260. Xvoid InitTextureTable PARAMS((void));
  261. Xvoid InitRTable PARAMS((void));
  262. Xint R PARAMS((VECTOR *v));
  263. Xint Crc16 PARAMS((char *buf, int count));
  264. XDBL Noise PARAMS((DBL x, DBL y, DBL z));
  265. Xvoid DNoise PARAMS((VECTOR *result, DBL x, DBL y, DBL z));
  266. XDBL cycloidal PARAMS((DBL value));
  267. XDBL Triangle_Wave PARAMS((DBL value));
  268. XDBL Turbulence PARAMS((DBL x, DBL y, DBL z));
  269. Xvoid DTurbulence PARAMS((VECTOR *result, DBL x, DBL y, DBL z));
  270. Xint Bozo PARAMS((DBL x, DBL y, DBL z, OBJECT *Object, COLOUR *Colour));
  271. Xint marble PARAMS((DBL x, DBL y, DBL z, OBJECT *Object, COLOUR *colour));
  272. Xvoid ripples PARAMS((DBL x, DBL y, DBL z, OBJECT *Object, VECTOR *Vector));
  273. Xvoid waves PARAMS((DBL x, DBL y, DBL z, OBJECT *Object, VECTOR *Vector));
  274. Xint wood PARAMS((DBL x, DBL y, DBL z, OBJECT *Object, COLOUR *colour));
  275. Xvoid checker PARAMS((DBL x, DBL y, DBL z, OBJECT *Object, COLOUR *colour));
  276. Xvoid spotted PARAMS((DBL x, DBL y, DBL z, OBJECT *Object, COLOUR *Colour));
  277. Xvoid bumps PARAMS((DBL x, DBL y, DBL z, OBJECT *Object, VECTOR *normal));
  278. Xvoid dents PARAMS((DBL x, DBL y, DBL z, OBJECT *Object, VECTOR *normal));
  279. Xvoid agate PARAMS((DBL x, DBL y, DBL z, OBJECT *Object, COLOUR *colour));
  280. Xvoid wrinkles PARAMS((DBL x, DBL y, DBL z, OBJECT *Object, VECTOR *normal));
  281. Xvoid granite PARAMS((DBL x, DBL y, DBL z, OBJECT *Object, COLOUR *Colour));
  282. Xvoid gradient PARAMS((DBL x, DBL y, DBL z, OBJECT *Object, COLOUR *Colour));
  283. Xvoid texture_map PARAMS((DBL x, DBL y, DBL z, OBJECT *Object, COLOUR *colour));
  284. X
  285. X/* Prototypes for functions defined in csg.c */
  286. Xint All_CSG_Union_Intersections PARAMS((OBJECT *Object, RAY *Ray, PRIOQ *Depth_Queue));
  287. Xint All_CSG_Intersection_Intersections PARAMS((OBJECT *Object, RAY *Ray, PRIOQ *Depth_Queue)); 
  288. Xint All_CSG_Difference_Intersections PARAMS((OBJECT *Object, RAY *Ray, PRIOQ *Depth_Queue));
  289. Xint Inside_CSG_Union PARAMS((VECTOR *Point, OBJECT *Object));
  290. Xint Inside_CSG_Intersection PARAMS((VECTOR *Point, OBJECT *Object));
  291. Xvoid *Copy_CSG PARAMS((OBJECT *Object));
  292. Xvoid Translate_CSG PARAMS((OBJECT *Object, VECTOR *Vector));
  293. Xvoid Rotate_CSG PARAMS((OBJECT *Object, VECTOR *Vector));
  294. Xvoid Scale_CSG PARAMS((OBJECT *Object, VECTOR *Vector));
  295. Xvoid Invert_CSG PARAMS((OBJECT *Object)); 
  296. X
  297. X/* Prototypes for functions defined in colour.c */
  298. XDBL Colour_Distance PARAMS((COLOUR *colour1, COLOUR *colour2));
  299. Xvoid Add_Colour PARAMS((COLOUR *result, COLOUR *colour1, COLOUR *colour2));
  300. Xvoid Scale_Colour PARAMS((COLOUR *result, COLOUR *colour, DBL factor));
  301. Xvoid Clip_Colour PARAMS((COLOUR *result, COLOUR *colour)); 
  302. X
  303. X/* Prototypes for functions defined in viewpnt.c */
  304. Xvoid *Copy_Viewpoint PARAMS((OBJECT *Object));
  305. Xvoid Translate_Viewpoint PARAMS((OBJECT *Object, VECTOR *Vector));
  306. Xvoid Rotate_Viewpoint PARAMS((OBJECT *Object, VECTOR *Vector));
  307. Xvoid Scale_Viewpoint PARAMS((OBJECT *Object, VECTOR *Vector));
  308. X
  309. X/* Prototypes for functions defined in ray.c */
  310. Xvoid Make_Ray PARAMS((RAY *r));
  311. Xvoid Initialize_Ray_Containers PARAMS((RAY *Ray));
  312. Xvoid Copy_Ray_Containers PARAMS((RAY *Dest_Ray, RAY *Source_Ray));
  313. Xvoid Ray_Enter PARAMS((RAY *ray, OBJECT *object));
  314. Xvoid Ray_Exit PARAMS((RAY *ray));
  315. X
  316. X/* Prototypes for functions defined in planes.c */
  317. Xint All_Plane_Intersections PARAMS((OBJECT *Object, RAY *Ray, PRIOQ *Depth_Queue));
  318. Xint Intersect_Plane PARAMS((RAY *Ray, PLANE *Plane, DBL *Depth));
  319. Xint Inside_Plane PARAMS((VECTOR *Point, OBJECT *Object));
  320. Xvoid Plane_Normal PARAMS((VECTOR *Result, OBJECT *Object, VECTOR *Intersection_Point));
  321. Xvoid *Copy_Plane PARAMS((OBJECT *Object));
  322. Xvoid Translate_Plane PARAMS((OBJECT *Object, VECTOR *Vector));
  323. Xvoid Rotate_Plane PARAMS((OBJECT *Object, VECTOR *Vector));
  324. Xvoid Scale_Plane PARAMS((OBJECT *Object, VECTOR *Vector));
  325. Xvoid Invert_Plane PARAMS((OBJECT *Object));
  326. X
  327. X/* Prototypes for functions defined in raw.c */
  328. Xint read_raw_byte PARAMS((FILE *f));
  329. Xint read_raw_word PARAMS((FILE *f));
  330. Xvoid read_raw_image PARAMS((IMAGE *Image, char *filename));
  331. X
  332. X/* Prototypes for functions defined in iff.c */
  333. Xvoid iff_error PARAMS((void));
  334. Xint read_byte PARAMS((FILE *f));
  335. Xint read_word PARAMS((FILE *f));
  336. Xlong read_long PARAMS((FILE *f));
  337. Xvoid Read_Chunk_Header PARAMS((FILE *f, CHUNK_HEADER *dest)); 
  338. Xvoid read_iff_image PARAMS((IMAGE *Image, char *filename));
  339. X
  340. X/* Prototypes for functions defined in gif.c */
  341. Xint out_line PARAMS((char *pixels, int linelen));
  342. Xint get_byte PARAMS((void));
  343. Xvoid read_gif_image PARAMS((IMAGE *Image, char *filename));
  344. X
  345. X/* Prototypes for functions defined in gifdecod.c */
  346. Xshort init_exp PARAMS((short size));
  347. Xshort get_next_code PARAMS((void));
  348. Xshort decoder PARAMS((short linewidth));
  349. X
  350. X/* Prototypes for functions defined in amiga.c */
  351. Xvoid display_finished PARAMS((void));
  352. Xvoid display_init PARAMS((void));
  353. Xvoid display_close PARAMS((void));
  354. Xvoid display_plot PARAMS((int x, int y, char Red, char Green, char Blue));
  355. X
  356. X/* Prototypes for functions defined in matrices.c */
  357. Xvoid MZero PARAMS((MATRIX *result));
  358. Xvoid MIdentity PARAMS((MATRIX *result));
  359. Xvoid MTimes PARAMS((MATRIX *result, MATRIX *matrix1, MATRIX *matrix2));
  360. Xvoid MAdd PARAMS((MATRIX *result, MATRIX *matrix1, MATRIX *matrix2));
  361. Xvoid MSub PARAMS((MATRIX *result, MATRIX *matrix1, MATRIX *matrix2));
  362. Xvoid MScale PARAMS((MATRIX *result, MATRIX *matrix1, DBL amount));
  363. Xvoid MTranspose PARAMS((MATRIX *result, MATRIX *matrix1));
  364. Xvoid MTransformVector PARAMS((VECTOR *result, VECTOR *vector, TRANSFORMATION *transformation));
  365. Xvoid MInverseTransformVector PARAMS((VECTOR *result, VECTOR *vector, TRANSFORMATION *transformation));
  366. Xvoid Get_Scaling_Transformation PARAMS((TRANSFORMATION *result, VECTOR *vector));
  367. Xvoid Get_Inversion_Transformation PARAMS((TRANSFORMATION *result));
  368. Xvoid Get_Translation_Transformation PARAMS((TRANSFORMATION *transformation, VECTOR *vector));
  369. Xvoid Get_Rotation_Transformation PARAMS((TRANSFORMATION *transformation, VECTOR *vector));
  370. Xvoid Get_Look_At_Transformation PARAMS((TRANSFORMATION *transformation, VECTOR *Look_At, VECTOR *Up, VECTOR *Right));
  371. Xvoid Compose_Transformations PARAMS((TRANSFORMATION *Original_Transformation, TRANSFORMATION *New_Transformation));
  372. END_OF_FILE
  373. if test 16900 -ne `wc -c <'src/dkbproto.h'`; then
  374.     echo shar: \"'src/dkbproto.h'\" unpacked with wrong size!
  375. fi
  376. # end of 'src/dkbproto.h'
  377. fi
  378. if test -f 'src/tokenize.c' -a "${1}" != "-c" ; then 
  379.   echo shar: Will not clobber existing file \"'src/tokenize.c'\"
  380. else
  381. echo shar: Extracting \"'src/tokenize.c'\" \(17489 characters\)
  382. sed "s/^X//" >'src/tokenize.c' <<'END_OF_FILE'
  383. X/*****************************************************************************
  384. X*
  385. X*                                     tokenize.c
  386. X*
  387. X*   from DKBTrace (c) 1990  David Buck
  388. X*
  389. X*  This module implements the first part of a two part parser for the scene
  390. X*  description files.  This phase changes the input file into tokens.
  391. X*
  392. X* This software is freely distributable. The source and/or object code may be
  393. X* copied or uploaded to communications services so long as this notice remains
  394. X* at the top of each file.  If any changes are made to the program, you must
  395. X* clearly indicate in the documentation and in the programs startup message
  396. X* who it was who made the changes. The documentation should also describe what
  397. X* those changes were. This software may not be included in whole or in
  398. X* part into any commercial package without the express written consent of the
  399. X* author.  It may, however, be included in other public domain or freely
  400. X* distributed software so long as the proper credit for the software is given.
  401. X*
  402. X* This software is provided as is without any guarantees or warranty. Although
  403. X* the author has attempted to find and correct any bugs in the software, he
  404. X* is not responsible for any damage caused by the use of the software.  The
  405. X* author is under no obligation to provide service, corrections, or upgrades
  406. X* to this package.
  407. X*
  408. X* Despite all the legal stuff above, if you do find bugs, I would like to hear
  409. X* about them.  Also, if you have any comments or questions, you may contact me
  410. X* at the following address:
  411. X*
  412. X*     David Buck
  413. X*     22C Sonnet Cres.
  414. X*     Nepean Ontario
  415. X*     Canada, K2H 8W7
  416. X*
  417. X*  I can also be reached on the following bulleton boards:
  418. X*
  419. X*     ATX              (613) 526-4141
  420. X*     OMX              (613) 731-3419
  421. X*     Mystic           (613) 731-0088 or (613) 731-6698
  422. X*
  423. X*  Fidonet:   1:163/109.9
  424. X*  Internet:  David_Buck@Carleton.CA
  425. X*
  426. X*  IBM Port by Aaron A. Collins. Aaron may be reached on the following BBS'es:
  427. X*
  428. X*     Lattice BBS                      (708) 916-1200
  429. X*     The Information Exchange BBS     (708) 945-5575
  430. X*     Stillwaters BBS                  (708) 403-2826
  431. X*
  432. X*****************************************************************************/
  433. X
  434. X#include <ctype.h>
  435. X#include "frame.h"
  436. X#include "dkbproto.h"
  437. X
  438. X/* This module tokenizes the input file to create a token file to be read
  439. Xby the parser (the second stage). Tokens written to the file contain a
  440. Xtoken ID, the line number of the token, and if necessary, some data for
  441. Xthe token.  */
  442. X
  443. X#define MAX_STRING_INDEX 20
  444. Xchar String[MAX_STRING_INDEX];
  445. Xint String_Index;
  446. Xint Line_Number = 1;
  447. X
  448. X/* Here are the reserved words.  If you need to add new words, be sure
  449. Xto declare them in frame.h */
  450. X
  451. Xstruct Reserved_Word_Struct Reserved_Words [LAST_TOKEN] = {
  452. XAGATE_TOKEN, "AGATE",
  453. XALPHA_TOKEN, "ALPHA",
  454. XAMBIENT_TOKEN, "AMBIENT",
  455. XAMPERSAND_TOKEN, "&",
  456. XAT_TOKEN, "@",
  457. XBACK_QUOTE_TOKEN, "`",
  458. XBACK_SLASH_TOKEN, "\\",
  459. XBAR_TOKEN, "|",
  460. XBLUE_TOKEN, "BLUE",
  461. XBRILLIANCE_TOKEN, "BRILLIANCE",
  462. XBOZO_TOKEN, "BOZO",
  463. XBOUNDED_TOKEN, "BOUNDED_BY",
  464. XBUMPS_TOKEN, "BUMPS",
  465. XCHECKER_TOKEN, "CHECKER",
  466. XCOLON_TOKEN, ":",
  467. XCOLOR_TOKEN, "COLOR",
  468. XCOLOUR_TOKEN, "COLOUR",
  469. XCOLOR_MAP_TOKEN, "COLOR_MAP",
  470. XCOLOUR_MAP_TOKEN, "COLOUR_MAP",
  471. XCOMMA_TOKEN, ",",
  472. XCOMPOSITE_TOKEN, "COMPOSITE",
  473. XDASH_TOKEN, "-",
  474. XDECLARE_TOKEN, "DECLARE",
  475. XDENTS_TOKEN, "DENTS",
  476. XDIFFERENCE_TOKEN, "DIFFERENCE",
  477. XDIFFUSE_TOKEN, "DIFFUSE",
  478. XDIRECTION_TOKEN, "DIRECTION",
  479. XDOLLAR_TOKEN, "$",
  480. XEND_BOUNDED_TOKEN, "END_BOUND",
  481. XEND_COLOR_MAP_TOKEN, "END_COLOR_MAP",
  482. XEND_COLOUR_MAP_TOKEN, "END_COLOUR_MAP",
  483. XEND_COMPOSITE_TOKEN, "END_COMPOSITE",
  484. XEND_DIFFERENCE_TOKEN, "END_DIFFERENCE",
  485. XEND_FOG_TOKEN, "END_FOG",
  486. XEND_INTERSECTION_TOKEN, "END_INTERSECTION",
  487. XEND_OBJECT_TOKEN, "END_OBJECT",
  488. XEND_OF_FILE_TOKEN, "End of File",
  489. XEND_PLANE_TOKEN, "END_PLANE",
  490. XEND_POINTS_TOKEN, "END_POINTS",
  491. XEND_POLYGON_TOKEN, "END_POLYGON",
  492. XEND_QUADRIC_TOKEN, "END_QUADRIC",
  493. XEND_SHAPE_TOKEN, "END_SHAPE",
  494. XEND_SPHERE_TOKEN, "END_SPHERE",
  495. XEND_TEXTURE_TOKEN, "END_TEXTURE",
  496. XEND_TRIANGLE_TOKEN, "END_TRIANGLE",
  497. XEND_UNION_TOKEN, "END_UNION",
  498. XEND_VIEW_POINT_TOKEN, "END_VIEW_POINT",
  499. XEQUALS_TOKEN, "=",
  500. XEXCLAMATION_TOKEN, "!",
  501. XFLOAT_TOKEN, "FLOAT",
  502. XFOG_TOKEN, "FOG",
  503. XFREQUENCY_TOKEN, "FREQUENCY",
  504. XGIF_TOKEN, "GIF",
  505. XGRANITE_TOKEN, "GRANITE",
  506. XGRADIENT_TOKEN, "GRADIENT",
  507. XGREEN_TOKEN, "GREEN",
  508. XHASH_TOKEN, "#",
  509. XHAT_TOKEN, "^",
  510. XIDENTIFIER_TOKEN, "IDENTIFIER",
  511. XIFF_TOKEN, "IFF",
  512. XIMAGEMAP_TOKEN, "IMAGEMAP",
  513. XINCLUDE_TOKEN, "INCLUDE",
  514. XINTERSECTION_TOKEN, "INTERSECTION",
  515. XINVERSE_TOKEN, "INVERSE",
  516. XIOR_TOKEN, "IOR",
  517. XLEFT_ANGLE_TOKEN, "<",
  518. XLEFT_BRACKET_TOKEN, "{",
  519. XLEFT_SQUARE_TOKEN, "[",
  520. XLIGHT_SOURCE_TOKEN, "LIGHT_SOURCE",
  521. XLOCATION_TOKEN, "LOCATION",
  522. XLOOK_AT_TOKEN, "LOOK_AT",
  523. XMARBLE_TOKEN, "MARBLE",
  524. XOBJECT_TOKEN, "OBJECT",
  525. XONCE_TOKEN, "ONCE",
  526. XPERCENT_TOKEN, "%",
  527. XPHASE_TOKEN, "PHASE",
  528. XPHONG_TOKEN, "PHONG",
  529. XPHONGSIZE_TOKEN, "PHONGSIZE",
  530. XPLANE_TOKEN, "PLANE",
  531. XPLUS_TOKEN, "+",
  532. XPOINTS_TOKEN, "POINTS",
  533. XPOLYGON_TOKEN, "POLYGON",
  534. XQUADRIC_TOKEN, "QUADRIC",
  535. XQUESTION_TOKEN, "?",
  536. XRAW_TOKEN, "RAW",
  537. XRED_TOKEN, "RED",
  538. XREFLECTION_TOKEN, "REFLECTION",
  539. XREFRACTION_TOKEN, "REFRACTION",
  540. XREVOLVE_TOKEN, "REVOLVE",
  541. XRIGHT_TOKEN, "RIGHT",
  542. XRIGHT_ANGLE_TOKEN, ">",
  543. XRIGHT_BRACKET_TOKEN, ")",
  544. XRIGHT_SQUARE_TOKEN, "]",
  545. XRIPPLES_TOKEN, "RIPPLES",
  546. XROTATE_TOKEN, "ROTATE",
  547. XROUGHNESS_TOKEN, "ROUGHNESS",
  548. XSCALE_TOKEN, "SCALE",
  549. XSEMI_COLON_TOKEN, ";",
  550. XSHAPE_TOKEN, "SHAPE",
  551. XSKY_TOKEN, "SKY",
  552. XSINGLE_QUOTE_TOKEN, "'",
  553. XSIZE_TOKEN, "SIZE",
  554. XSLASH_TOKEN, "/",
  555. XSMOOTH_TRIANGLE_TOKEN, "SMOOTH_TRIANGLE",
  556. XSPECULAR_TOKEN, "SPECULAR",
  557. XSPHERE_TOKEN, "SPHERE",
  558. XSPOTTED_TOKEN, "SPOTTED",
  559. XSTAR_TOKEN, "*",
  560. XSTRING_TOKEN, "STRING",
  561. XTEXTURE_TOKEN, "TEXTURE",
  562. XTILDE_TOKEN, "~",
  563. XTRANSLATE_TOKEN, "TRANSLATE",
  564. XTRIANGLE_TOKEN, "TRIANGLE",
  565. XTURBULENCE_TOKEN, "TURBULENCE",
  566. XUNION_TOKEN, "UNION",
  567. XUP_TOKEN, "UP",
  568. XVIEW_POINT_TOKEN, "VIEW_POINT",
  569. XWAVES_TOKEN, "WAVES",
  570. XWOOD_TOKEN, "WOOD",
  571. XWRINKLES_TOKEN, "WRINKLES"
  572. X  };
  573. X
  574. X/* Make a table for user-defined symbols.  200 symbols should be more
  575. Xthan enough. */
  576. X
  577. X#define MAX_SYMBOLS 200
  578. X
  579. X/* Hard code symbols to be a maximum of 40 characters long */
  580. Xchar Symbol_Table[MAX_SYMBOLS][40];
  581. Xint Number_Of_Symbols;
  582. X
  583. Xchar File_Name[FILE_NAME_LENGTH];
  584. X
  585. Xextern FILE *Data_File, *Token_File, *Symbol_File;
  586. X#define CALL(x) { if (!(x)) return (FALSE); }
  587. X
  588. X/* The main tokenizing routine.  Set up the files and continue parsing
  589. Xuntil the end of file */
  590. X
  591. Xvoid Tokenize (name, in, symbol, out)
  592. X  char *name;
  593. X  FILE *in, *symbol, *out;
  594. X  {
  595. X/* Keep track of the file name so we don't get confused when we
  596. X    return from INCLUDE files */
  597. X
  598. X  strcpy (File_Name, name);
  599. X  Data_File = in;
  600. X  Token_File = out;
  601. X  Symbol_File = symbol;
  602. X  Number_Of_Symbols = 0;
  603. X
  604. X/* Let the parser know the name of the file we are tokenizing */
  605. X  strcpy (String, name);
  606. X  Write_Token (INCLUDE_TOKEN);
  607. X
  608. X  while (Process_Token()) ;
  609. X  }
  610. X
  611. X/* This function performs most of the work involved in tokenizing.  It
  612. X   reads the first character of the token and decides which function to
  613. X   call to tokenize the rest.  For simple tokens, it simply writes them
  614. X   out to the token file.  */
  615. X
  616. Xint Process_Token ()
  617. X  {
  618. X  register int c;
  619. X
  620. X  Skip_Spaces ();
  621. X
  622. X  c = getc(Data_File);
  623. X  if (c == EOF)
  624. X    return (FALSE);
  625. X
  626. X  String[0] = '\0';
  627. X
  628. X  switch (c)
  629. X    {
  630. X    case '\n': Line_Number++;
  631. X               break;
  632. X
  633. X    case '{' : Parse_Comments();
  634. X               break;
  635. X
  636. X    case '@' : Write_Token (AT_TOKEN);
  637. X               break;
  638. X
  639. X    case '&' : Write_Token (AMPERSAND_TOKEN);
  640. X               break;
  641. X
  642. X    case '`' : Write_Token (BACK_QUOTE_TOKEN);
  643. X               break;
  644. X
  645. X    case '\\': Write_Token (BACK_SLASH_TOKEN);
  646. X               break;
  647. X
  648. X    case '|' : Write_Token (BAR_TOKEN);
  649. X               break;
  650. X
  651. X    case ':' : Write_Token (COLON_TOKEN);
  652. X               break;
  653. X
  654. X    case ',' : Write_Token (COMMA_TOKEN);
  655. X               break;
  656. X
  657. X    case '-' : Write_Token (DASH_TOKEN);
  658. X               break;
  659. X
  660. X    case '$' : Write_Token (DOLLAR_TOKEN);
  661. X               break;
  662. X
  663. X    case '=' : Write_Token (EQUALS_TOKEN);
  664. X               break;
  665. X
  666. X    case '!' : Write_Token (EXCLAMATION_TOKEN);
  667. X               break;
  668. X
  669. X    case '#' : Write_Token (HASH_TOKEN);
  670. X               break;
  671. X
  672. X    case '^' : Write_Token (HAT_TOKEN);
  673. X               break;
  674. X
  675. X    case '<' : Write_Token (LEFT_ANGLE_TOKEN);
  676. X               break;
  677. X
  678. X    case '(' : Write_Token (LEFT_BRACKET_TOKEN);
  679. X               break;
  680. X
  681. X    case '[' : Write_Token (LEFT_SQUARE_TOKEN);
  682. X               break;
  683. X
  684. X    case '%' :  Write_Token (PERCENT_TOKEN);
  685. X               break;
  686. X
  687. X    case '+' : Write_Token (PLUS_TOKEN);
  688. X               break;
  689. X
  690. X    case '?' : Write_Token (QUESTION_TOKEN);
  691. X               break;
  692. X
  693. X    case '>' : Write_Token (RIGHT_ANGLE_TOKEN);
  694. X               break;
  695. X
  696. X    case ')' : Write_Token (RIGHT_BRACKET_TOKEN);
  697. X               break;
  698. X
  699. X    case ']' : Write_Token (RIGHT_SQUARE_TOKEN);
  700. X               break;
  701. X
  702. X    case ';' : Write_Token (SEMI_COLON_TOKEN);
  703. X               break;
  704. X
  705. X    case '\'': Write_Token (SINGLE_QUOTE_TOKEN);
  706. X               break;
  707. X
  708. X    case '/' : Write_Token (SLASH_TOKEN);
  709. X               break;
  710. X
  711. X    case '*' : Write_Token (STAR_TOKEN);
  712. X               break;
  713. X
  714. X    case '~' : Write_Token (TILDE_TOKEN);
  715. X               break;
  716. X
  717. X    case '"' : Parse_String ();
  718. X               break;
  719. X
  720. X    case '0':   case '1':   case '2':   case '3':   case '4':   case '5':
  721. X    case '6':   case '7':   case '8':   case '9':
  722. X               ungetc (c, Data_File);
  723. X               CALL (Read_Float ());
  724. X               break;
  725. X
  726. X    case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
  727. X    case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n':
  728. X    case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u':
  729. X    case 'v': case 'w': case 'x': case 'y': case 'z':
  730. X    case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G':
  731. X    case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N':
  732. X    case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U':
  733. X    case 'V': case 'W': case 'X': case 'Y': case 'Z': case '_':
  734. X               ungetc (c, Data_File);
  735. X               CALL (Read_Symbol ());
  736. X               break;
  737. X
  738. X    default:
  739. X      printf ("Error on line %d\n", Line_Number);
  740. X      printf ("Illegal character in input file, value is %02x\n", c);
  741. X      break;
  742. X    }
  743. X  return (TRUE);
  744. X  }
  745. X
  746. X
  747. X/* Skip over spaces in the input file */
  748. X
  749. Xint Skip_Spaces ()
  750. X  {
  751. X  register int c;
  752. X
  753. X  while (TRUE)
  754. X    {
  755. X    c = getc(Data_File);
  756. X    if (c == EOF)
  757. X      return (FALSE);
  758. X
  759. X    if (!isspace(c))
  760. X      break;
  761. X
  762. X    if (c == '\n')
  763. X       Line_Number++;
  764. X    }
  765. X
  766. X  ungetc (c, Data_File);
  767. X  return (TRUE);
  768. X  }
  769. X
  770. X/* Comments start with an open brace ({) and end with a close brace (}).
  771. X   The open brace has been read already.  Continue reading until a close
  772. X   brace is encountered. Be sure to count the lines while you're at it.
  773. X   Incidently, nested comments are supported (in case you do such esoteric
  774. X   things) */
  775. X
  776. Xint Parse_Comments ()
  777. X  {
  778. X  register int c;
  779. X  int End_Of_Comment;
  780. X  
  781. X  End_Of_Comment = FALSE;
  782. X  while (!End_Of_Comment)
  783. X    {
  784. X    c = getc (Data_File);
  785. X    if (c == EOF)
  786. X      {
  787. X      Token_Error ("No closing comment found");
  788. X      return (FALSE);
  789. X      }
  790. X
  791. X    if (c == (int) '\n')
  792. X      Line_Number++;
  793. X
  794. X    if (c == (int) '{')
  795. X      CALL (Parse_Comments())
  796. X    else
  797. X      End_Of_Comment = (c == (int) '}');
  798. X    }
  799. X
  800. X  return (TRUE);
  801. X  }
  802. X
  803. X/* The following routines make it easier to handle strings.  They stuff
  804. X   characters into a string buffer one at a time making all the proper
  805. X   range checks.  Call Begin_String to start, Stuff_Character to put
  806. X   characters in, and End_String to finish.  The String variable contains
  807. X   the final string. */
  808. X
  809. Xvoid Begin_String()
  810. X  {
  811. X  String_Index = 0;
  812. X  }
  813. X
  814. Xvoid Stuff_Character (c)
  815. X  char c;
  816. X  {
  817. X  if (String_Index < MAX_STRING_INDEX)
  818. X    {
  819. X    String [String_Index++] = c;
  820. X    if (String_Index >= MAX_STRING_INDEX)
  821. X      {
  822. X      Token_Error ("String too long");
  823. X      String [String_Index-1] = '\0';
  824. X      }
  825. X    }
  826. X  }
  827. X
  828. Xvoid End_String ()
  829. X  {
  830. X  Stuff_Character ('\0');
  831. X  }
  832. X
  833. X/* Read a float from the input file and tokenize it as one token. The phase
  834. X   variable is 0 for the first character, 1 for all subsequent characters
  835. X   up to the decimal point, and 2 for all characters after the decimal
  836. X   point.  This helps to insure that the number is formatted properly. */
  837. X
  838. Xint Read_Float()
  839. X  {
  840. X  register int c, Finished, Phase;
  841. X
  842. X  Finished = FALSE;
  843. X  Phase = 0;
  844. X
  845. X  Begin_String();
  846. X  while (!Finished)
  847. X    {
  848. X    c = getc(Data_File);
  849. X    if (c == EOF)
  850. X      {
  851. X      Token_Error ("Unexpected end of file");
  852. X      return (FALSE);
  853. X      }
  854. X
  855. X    switch (Phase)
  856. X      {
  857. X      case 0: if (isdigit(c))
  858. X                Stuff_Character((char) c);
  859. X              else
  860. X                Token_Error ("Error in decimal number");
  861. X              Phase = 1;
  862. X              break;
  863. X     
  864. X      case 1: if (isdigit(c))
  865. X                Stuff_Character((char) c);
  866. X              else if (c == (int) '.')
  867. X                {
  868. X                Stuff_Character((char) c);
  869. X                Phase = 2;
  870. X                }
  871. X              else
  872. X                Finished = TRUE;
  873. X              break;
  874. X
  875. X      case 2: if (isdigit(c))
  876. X                Stuff_Character((char) c);
  877. X              else
  878. X                Finished = TRUE;
  879. X              break;
  880. X      }
  881. X    }
  882. X
  883. X  ungetc (c, Data_File);
  884. X  End_String();
  885. X
  886. X  Write_Token (FLOAT_TOKEN);
  887. X  return (TRUE);
  888. X  }
  889. X
  890. X/* Parse a string from the input file into a token. */
  891. Xint Parse_String ()
  892. X  {
  893. X  register int c;
  894. X
  895. X  Begin_String();
  896. X  while (TRUE)
  897. X    {
  898. X    c = getc(Data_File);
  899. X    if (c == EOF)
  900. X      {
  901. X      Token_Error ("No end quote for string");
  902. X      return (FALSE);
  903. X      }
  904. X
  905. X    if (c != (int) '"')
  906. X      Stuff_Character ((char) c);
  907. X    else
  908. X      break;
  909. X    }
  910. X  End_String();
  911. X
  912. X  Write_Token (STRING_TOKEN);
  913. X
  914. X  return (TRUE);
  915. X  }
  916. X
  917. X/* Read an include file.  This can be a bit tricky.  The old files are saved
  918. X   in local variables while the include file is being read.  We have to
  919. X   write out an INCLUDE token when we start to tell the parser the name of
  920. X   the file we're in.  We have to write another INCLUDE token when we finish
  921. X   to tell the parser that we're back.  */
  922. X
  923. Xint Read_Include ()
  924. X  {
  925. X  register int c;
  926. X  FILE *new_file, *original_file;
  927. X  register int Old_Line_Number;
  928. X  char Old_File_Name[FILE_NAME_LENGTH];
  929. X
  930. X  Skip_Spaces();
  931. X  if (getc(Data_File) != (int) '\"') {
  932. X     printf ("Start quote expected\n");
  933. X     exit (0);
  934. X     }
  935. X
  936. X  Begin_String();
  937. X  while (TRUE)
  938. X    {
  939. X    c = getc(Data_File);
  940. X    if (c == EOF)
  941. X      {
  942. X      Token_Error ("No end quote for string");
  943. X      return (FALSE);
  944. X      }
  945. X
  946. X    if (c != (int) '"')
  947. X      Stuff_Character ((char) c);
  948. X    else
  949. X      break;
  950. X    }
  951. X  End_String();
  952. X
  953. X  if ((new_file = fopen (String, "r")) == NULL) {
  954. X     printf ("Cannot open include file %s\n", String);
  955. X     close_all();
  956. X     exit(1);
  957. X     }
  958. X
  959. X  Write_Token (INCLUDE_TOKEN);
  960. X  Old_Line_Number = Line_Number;
  961. X  Line_Number = 1;
  962. X  original_file = Data_File;
  963. X  strcpy (Old_File_Name, File_Name);
  964. X
  965. X  Tokenize (String, new_file, Symbol_File, Token_File);
  966. X
  967. X  fclose (new_file);
  968. X  Data_File = original_file;
  969. X  Line_Number = Old_Line_Number;
  970. X  strcpy (File_Name, Old_File_Name);
  971. X  strcpy (String, Old_File_Name);
  972. X  Write_Token (INCLUDE_TOKEN);
  973. X  return (TRUE);
  974. X  }
  975. X
  976. X/* Read    in a symbol from the input file.  Check to see if it is a reserved
  977. X   word.  If it is, write out the appropriate token.  Otherwise, write the
  978. X   symbol out to the Symbol file and write out an IDENTIFIER token. An
  979. X   Identifier token is a token whose token number is greater than the
  980. X   highest reserved word. */
  981. X
  982. Xint Read_Symbol ()
  983. X  {
  984. X  register int c, Symbol_Id;
  985. X
  986. X  Begin_String();
  987. X  while (TRUE)
  988. X    {
  989. X    c = getc(Data_File);
  990. X    if (c == EOF)
  991. X      {
  992. X      Token_Error ("Unexpected end of file");
  993. X      return (FALSE);
  994. X      }
  995. X
  996. X    if (isalpha(c) || isdigit(c) || c == (int) '_')
  997. X      Stuff_Character ((char) c);
  998. X    else
  999. X      {
  1000. X      ungetc (c, Data_File);
  1001. X      break;
  1002. X      }
  1003. X    }
  1004. X  End_String();
  1005. X
  1006. X  if ((Symbol_Id = Find_Reserved()) != -1)
  1007. X
  1008. X/* INCLUDE is a reserved word, but we want to handle it separately */
  1009. X
  1010. X    if (Symbol_Id == INCLUDE_TOKEN)
  1011. X       Read_Include();
  1012. X    else
  1013. X       Write_Token (Symbol_Id);
  1014. X  else
  1015. X    {
  1016. X    if ((Symbol_Id = Find_Symbol()) == -1)
  1017. X      if (++Number_Of_Symbols < MAX_SYMBOLS)
  1018. X        {
  1019. X        strncpy (&Symbol_Table[Number_Of_Symbols][0], &String[0], 39);
  1020. X    Symbol_Table[Number_Of_Symbols][39] = '\0';
  1021. X        fprintf (Symbol_File, "%s%\n", &String[0]);
  1022. X        Symbol_Id = Number_Of_Symbols;
  1023. X        }
  1024. X      else
  1025. X        {
  1026. X        printf ("\nToo many symbols\n");
  1027. X        exit(0);
  1028. X        }
  1029. X
  1030. X    Write_Token (LAST_TOKEN + Symbol_Id);
  1031. X    }
  1032. X
  1033. X  return (TRUE);
  1034. X  }
  1035. X
  1036. X/* Return the index the token in the reserved words table or -1 if it
  1037. X   isn't there. */
  1038. X
  1039. Xint Find_Reserved ()
  1040. X  {
  1041. X  register int i;
  1042. X
  1043. X  for (i = 0 ; i < LAST_TOKEN ; i++)
  1044. X    if (strcmp (Reserved_Words[i].Token_Name, &(String[0])) == 0)
  1045. X      return (Reserved_Words[i].Token_Number);
  1046. X
  1047. X  return (-1);
  1048. X  }
  1049. X
  1050. X/* Check to see if a symbol already exists with this name.  If so, return
  1051. X    its symbol ID. */
  1052. X
  1053. Xint Find_Symbol ()
  1054. X  {
  1055. X  register int i;
  1056. X
  1057. X  for (i = 1 ; i <= Number_Of_Symbols ; i++)
  1058. X    if (strcmp (&Symbol_Table[i][0], &(String[0])) == 0)
  1059. X      return (i);
  1060. X
  1061. X  return (-1);
  1062. X  }
  1063. X
  1064. X/* Write a token out to the token file */
  1065. Xvoid Write_Token (Token_Id)
  1066. X  TOKEN Token_Id;
  1067. X  {
  1068. X  fprintf (Token_File, "%d %d %s\n", Token_Id, Line_Number, String);
  1069. X  }                    /* Was (long) Token_Id... */
  1070. X
  1071. X/* Report an error */
  1072. Xvoid Token_Error (str)
  1073. X  char *str;
  1074. X  {
  1075. X  printf ("Error on line %d\n", Line_Number);
  1076. X  puts(str);
  1077. X  puts("\n\n");
  1078. X  }
  1079. END_OF_FILE
  1080. if test 17489 -ne `wc -c <'src/tokenize.c'`; then
  1081.     echo shar: \"'src/tokenize.c'\" unpacked with wrong size!
  1082. fi
  1083. # end of 'src/tokenize.c'
  1084. fi
  1085. if test -f 'src/triangle.c' -a "${1}" != "-c" ; then 
  1086.   echo shar: Will not clobber existing file \"'src/triangle.c'\"
  1087. else
  1088. echo shar: Extracting \"'src/triangle.c'\" \(17931 characters\)
  1089. sed "s/^X//" >'src/triangle.c' <<'END_OF_FILE'
  1090. X/*****************************************************************************
  1091. X*
  1092. X*                                      triangle.c
  1093. X*
  1094. X*   from DKBTrace (c) 1990  David Buck
  1095. X*
  1096. X*  This module implements primitives for triangles and smooth triangles.
  1097. X*
  1098. X* This software is freely distributable. The source and/or object code may be
  1099. X* copied or uploaded to communications services so long as this notice remains
  1100. X* at the top of each file.  If any changes are made to the program, you must
  1101. X* clearly indicate in the documentation and in the programs startup message
  1102. X* who it was who made the changes. The documentation should also describe what
  1103. X* those changes were. This software may not be included in whole or in
  1104. X* part into any commercial package without the express written consent of the
  1105. X* author.  It may, however, be included in other public domain or freely
  1106. X* distributed software so long as the proper credit for the software is given.
  1107. X*
  1108. X* This software is provided as is without any guarantees or warranty. Although
  1109. X* the author has attempted to find and correct any bugs in the software, he
  1110. X* is not responsible for any damage caused by the use of the software.  The
  1111. X* author is under no obligation to provide service, corrections, or upgrades
  1112. X* to this package.
  1113. X*
  1114. X* Despite all the legal stuff above, if you do find bugs, I would like to hear
  1115. X* about them.  Also, if you have any comments or questions, you may contact me
  1116. X* at the following address:
  1117. X*
  1118. X*     David Buck
  1119. X*     22C Sonnet Cres.
  1120. X*     Nepean Ontario
  1121. X*     Canada, K2H 8W7
  1122. X*
  1123. X*  I can also be reached on the following bulleton boards:
  1124. X*
  1125. X*     ATX              (613) 526-4141
  1126. X*     OMX              (613) 731-3419
  1127. X*     Mystic           (613) 731-0088 or (613) 731-6698
  1128. X*
  1129. X*  Fidonet:   1:163/109.9
  1130. X*  Internet:  David_Buck@Carleton.CA
  1131. X*
  1132. X*  IBM Port by Aaron A. Collins. Aaron may be reached on the following BBS'es:
  1133. X*
  1134. X*     Lattice BBS                      (708) 916-1200
  1135. X*     The Information Exchange BBS     (708) 945-5575
  1136. X*     Stillwaters BBS                  (708) 403-2826
  1137. X*
  1138. X*****************************************************************************/
  1139. X
  1140. X#include "frame.h"
  1141. X#include "vector.h"
  1142. X#include "dkbproto.h"
  1143. X
  1144. XMETHODS Triangle_Methods = {
  1145. X     Object_Intersect, All_Triangle_Intersections,
  1146. X     Inside_Triangle, Triangle_Normal,
  1147. X     Copy_Triangle,
  1148. X     Translate_Triangle, Rotate_Triangle,
  1149. X     Scale_Triangle, Invert_Triangle};
  1150. X
  1151. XMETHODS Smooth_Triangle_Methods = {
  1152. X     Object_Intersect, All_Triangle_Intersections,
  1153. X     Inside_Triangle, Smooth_Triangle_Normal,
  1154. X     Copy_Smooth_Triangle,
  1155. X     Translate_Triangle, Rotate_Smooth_Triangle,
  1156. X     Scale_Triangle, Invert_Triangle};
  1157. X
  1158. Xextern TRIANGLE *Get_Triangle_Shape();
  1159. X
  1160. Xextern RAY *VP_Ray;
  1161. Xextern long Ray_Triangle_Tests, Ray_Triangle_Tests_Succeeded;
  1162. X
  1163. X#define max3(x,y,z) ((x>y)?((x>z)?1:3):((y>z)?2:3))
  1164. X
  1165. Xvoid Find_Triangle_Dominant_Axis(Triangle)
  1166. X   TRIANGLE *Triangle;
  1167. X   {
  1168. X   DBL x, y, z;
  1169. X
  1170. X   x = fabs(Triangle->Normal_Vector.x);
  1171. X   y = fabs (Triangle->Normal_Vector.y);
  1172. X   z = fabs (Triangle->Normal_Vector.z);
  1173. X   switch (max3(x, y, z)) {
  1174. X      case 1: Triangle->Dominant_Axis = X_AXIS;
  1175. X              break;
  1176. X      case 2: Triangle->Dominant_Axis = Y_AXIS;
  1177. X              break;
  1178. X      case 3: Triangle->Dominant_Axis = Z_AXIS;
  1179. X              break;
  1180. X      }
  1181. X   }
  1182. X
  1183. Xvoid Compute_Smooth_Triangle (Triangle)
  1184. X   SMOOTH_TRIANGLE *Triangle;
  1185. X   {
  1186. X   VECTOR P3MinusP2, VTemp1, VTemp2;
  1187. X   DBL x, y, z, uDenominator, Proj;
  1188. X
  1189. X   VSub (P3MinusP2, Triangle->P3, Triangle->P2);
  1190. X   x = fabs (P3MinusP2.x);
  1191. X   y = fabs (P3MinusP2.y);
  1192. X   z = fabs (P3MinusP2.z);
  1193. X
  1194. X   switch (max3 (x, y, z)) {
  1195. X      case 1:  Triangle->vAxis = X_AXIS;
  1196. X               Triangle->BaseDelta = P3MinusP2.x;
  1197. X               break;
  1198. X
  1199. X      case 2:  Triangle->vAxis = Y_AXIS;
  1200. X               Triangle->BaseDelta = P3MinusP2.y;
  1201. X               break;
  1202. X
  1203. X      case 3:  Triangle->vAxis = Z_AXIS;
  1204. X               Triangle->BaseDelta = P3MinusP2.z;
  1205. X               break;
  1206. X      }   
  1207. X
  1208. X   VSub (VTemp1, Triangle->P2, Triangle->P3);
  1209. X   VNormalize (VTemp1, VTemp1);
  1210. X   VSub (VTemp2, Triangle->P1, Triangle->P3);
  1211. X   VDot (Proj, VTemp2, VTemp1);
  1212. X   VScale (VTemp1, VTemp1, Proj);
  1213. X   VSub (Triangle->Perp, VTemp1, VTemp2);
  1214. X   VNormalize (Triangle->Perp, Triangle->Perp);
  1215. X   VDot (uDenominator, VTemp2, Triangle->Perp);
  1216. X   uDenominator = -1.0 / uDenominator;
  1217. X   VScale (Triangle->Perp, Triangle->Perp, uDenominator);
  1218. X   }
  1219. X
  1220. Xint Compute_Triangle (Triangle)
  1221. X   TRIANGLE *Triangle;
  1222. X   {
  1223. X   VECTOR V1, V2, Temp;
  1224. X   DBL Length;
  1225. X
  1226. X   VSub (V1, Triangle->P1, Triangle->P2);
  1227. X   VSub (V2, Triangle->P3, Triangle->P2);
  1228. X   VCross (Triangle->Normal_Vector, V1, V2);
  1229. X   VLength (Length, Triangle->Normal_Vector);
  1230. X   if (Length < 1.0e-9)
  1231. X      return (0);
  1232. X
  1233. X   VDot (Triangle->Distance, Triangle->Normal_Vector, Triangle->P1);
  1234. X   Triangle->Distance *= -1.0;
  1235. X   Find_Triangle_Dominant_Axis(Triangle);
  1236. X
  1237. X   switch (Triangle->Dominant_Axis) {
  1238. X      case X_AXIS:
  1239. X         if ((Triangle->P2.y - Triangle->P3.y)*(Triangle->P2.z - Triangle->P1.z) <
  1240. X             (Triangle->P2.z - Triangle->P3.z)*(Triangle->P2.y - Triangle->P1.y)) {
  1241. X
  1242. X             Temp = Triangle->P2;
  1243. X             Triangle->P2 = Triangle->P1;
  1244. X             Triangle->P1 = Temp;
  1245. X             }
  1246. X          break;
  1247. X
  1248. X      case Y_AXIS:
  1249. X         if ((Triangle->P2.x - Triangle->P3.x)*(Triangle->P2.z - Triangle->P1.z) <
  1250. X             (Triangle->P2.z - Triangle->P3.z)*(Triangle->P2.x - Triangle->P1.x)) {
  1251. X
  1252. X             Temp = Triangle->P2;
  1253. X             Triangle->P2 = Triangle->P1;
  1254. X             Triangle->P1 = Temp;
  1255. X             }
  1256. X          break;
  1257. X
  1258. X      case Z_AXIS:
  1259. X         if ((Triangle->P2.x - Triangle->P3.x)*(Triangle->P2.y - Triangle->P1.y) <
  1260. X             (Triangle->P2.y - Triangle->P3.y)*(Triangle->P2.x - Triangle->P1.x)) {
  1261. X
  1262. X             Temp = Triangle->P2;
  1263. X             Triangle->P2 = Triangle->P1;
  1264. X             Triangle->P1 = Temp;
  1265. X             }
  1266. X          break;
  1267. X      }
  1268. X
  1269. X   if (Triangle->Type == SMOOTH_TRIANGLE_TYPE)
  1270. X      Compute_Smooth_Triangle((SMOOTH_TRIANGLE *) Triangle);
  1271. X   return (1);
  1272. X   }
  1273. X
  1274. Xint All_Triangle_Intersections (Object, Ray, Depth_Queue)
  1275. X  OBJECT *Object;
  1276. X  RAY *Ray;
  1277. X  PRIOQ *Depth_Queue;
  1278. X  {
  1279. X  TRIANGLE *Shape = (TRIANGLE *) Object;
  1280. X  DBL Depth;
  1281. X  VECTOR Intersection_Point;
  1282. X  INTERSECTION Local_Element;
  1283. X
  1284. X  if (Intersect_Triangle (Ray, Shape, &Depth))
  1285. X    {
  1286. X    Local_Element.Depth = Depth;
  1287. X    Local_Element.Object = Shape -> Parent_Object;
  1288. X    VScale (Intersection_Point, Ray -> Direction, Depth);
  1289. X    VAdd (Intersection_Point, Intersection_Point, Ray -> Initial);
  1290. X    Local_Element.Point = Intersection_Point;
  1291. X    Local_Element.Shape = (SHAPE *)Shape;
  1292. X    pq_add (Depth_Queue, &Local_Element);
  1293. X    return (TRUE);
  1294. X    }
  1295. X  return (FALSE);
  1296. X  }
  1297. X
  1298. Xint Intersect_Triangle (Ray, Triangle, Depth)
  1299. X   RAY *Ray;
  1300. X   TRIANGLE *Triangle;
  1301. X   DBL *Depth;
  1302. X   {
  1303. X   DBL NormalDotOrigin, NormalDotDirection;
  1304. X   DBL s, t;
  1305. X
  1306. X   Ray_Triangle_Tests++;
  1307. X   if (Ray == VP_Ray) {
  1308. X      if (!Triangle->VPCached) {
  1309. X         VDot (Triangle->VPNormDotOrigin, Triangle->Normal_Vector, Ray->Initial);
  1310. X         Triangle->VPNormDotOrigin += Triangle->Distance;
  1311. X         Triangle->VPNormDotOrigin *= -1.0;
  1312. X         Triangle->VPCached = TRUE;
  1313. X         }
  1314. X
  1315. X      VDot (NormalDotDirection, Triangle->Normal_Vector, Ray->Direction);
  1316. X      if ((NormalDotDirection < Small_Tolerance) &&
  1317. X          (NormalDotDirection > -Small_Tolerance))
  1318. X         return (FALSE);
  1319. X
  1320. X      *Depth = Triangle->VPNormDotOrigin / NormalDotDirection;
  1321. X      }
  1322. X   else {
  1323. X      VDot (NormalDotOrigin, Triangle->Normal_Vector, Ray->Initial);
  1324. X      NormalDotOrigin += Triangle->Distance;
  1325. X      NormalDotOrigin *= -1.0;
  1326. X
  1327. X      VDot (NormalDotDirection, Triangle->Normal_Vector, Ray->Direction);
  1328. X      if ((NormalDotDirection < Small_Tolerance) &&
  1329. X          (NormalDotDirection > -Small_Tolerance))
  1330. X            return (FALSE);
  1331. X
  1332. X      *Depth = NormalDotOrigin / NormalDotDirection;
  1333. X      }
  1334. X
  1335. X   if ((*Depth < Small_Tolerance) || (*Depth > Max_Distance))
  1336. X      return (FALSE);
  1337. X
  1338. X   switch (Triangle->Dominant_Axis) {
  1339. X      case X_AXIS:
  1340. X         s = Ray->Initial.y + *Depth * Ray->Direction.y;
  1341. X         t = Ray->Initial.z + *Depth * Ray->Direction.z;
  1342. X
  1343. X         if ((Triangle->P2.y - s)*(Triangle->P2.z - Triangle->P1.z) <
  1344. X             (Triangle->P2.z - t)*(Triangle->P2.y - Triangle->P1.y))
  1345. X            if ((int) Triangle->Inverted) {
  1346. X               Ray_Triangle_Tests_Succeeded++;
  1347. X               return (TRUE);
  1348. X               }
  1349. X            else
  1350. X               return (FALSE);
  1351. X
  1352. X         if ((Triangle->P3.y - s)*(Triangle->P3.z - Triangle->P2.z) <
  1353. X             (Triangle->P3.z - t)*(Triangle->P3.y - Triangle->P2.y))
  1354. X            if ((int) Triangle->Inverted) {
  1355. X               Ray_Triangle_Tests_Succeeded++;
  1356. X               return (TRUE);
  1357. X               }
  1358. X            else
  1359. X               return (FALSE);
  1360. X
  1361. X         if ((Triangle->P1.y - s)*(Triangle->P1.z - Triangle->P3.z) <
  1362. X             (Triangle->P1.z - t)*(Triangle->P1.y - Triangle->P3.y))
  1363. X            if ((int) Triangle->Inverted) {
  1364. X               Ray_Triangle_Tests_Succeeded++;
  1365. X               return (TRUE);
  1366. X               }
  1367. X            else
  1368. X               return (FALSE);
  1369. X
  1370. X         if (!(int) Triangle->Inverted) {
  1371. X               Ray_Triangle_Tests_Succeeded++;
  1372. X               return (TRUE);
  1373. X               }
  1374. X            else
  1375. X               return (FALSE);
  1376. X
  1377. X      case Y_AXIS:
  1378. X         s = Ray->Initial.x + *Depth * Ray->Direction.x;
  1379. X         t = Ray->Initial.z + *Depth * Ray->Direction.z;
  1380. X
  1381. X         if ((Triangle->P2.x - s)*(Triangle->P2.z - Triangle->P1.z) <
  1382. X             (Triangle->P2.z - t)*(Triangle->P2.x - Triangle->P1.x))
  1383. X            if ((int) Triangle->Inverted) {
  1384. X               Ray_Triangle_Tests_Succeeded++;
  1385. X               return (TRUE);
  1386. X               }
  1387. X            else
  1388. X               return (FALSE);
  1389. X
  1390. X         if ((Triangle->P3.x - s)*(Triangle->P3.z - Triangle->P2.z) <
  1391. X             (Triangle->P3.z - t)*(Triangle->P3.x - Triangle->P2.x))
  1392. X            if ((int) Triangle->Inverted) {
  1393. X               Ray_Triangle_Tests_Succeeded++;
  1394. X               return (TRUE);
  1395. X               }
  1396. X            else
  1397. X               return (FALSE);
  1398. X
  1399. X         if ((Triangle->P1.x - s)*(Triangle->P1.z - Triangle->P3.z) <
  1400. X             (Triangle->P1.z - t)*(Triangle->P1.x - Triangle->P3.x))
  1401. X            if ((int) Triangle->Inverted) {
  1402. X               Ray_Triangle_Tests_Succeeded++;
  1403. X               return (TRUE);
  1404. X               }
  1405. X            else
  1406. X               return (FALSE);
  1407. X
  1408. X         if (!(int) Triangle->Inverted) {
  1409. X               Ray_Triangle_Tests_Succeeded++;
  1410. X               return (TRUE);
  1411. X               }
  1412. X            else
  1413. X               return (FALSE);
  1414. X
  1415. X      case Z_AXIS:
  1416. X         s = Ray->Initial.x + *Depth * Ray->Direction.x;
  1417. X         t = Ray->Initial.y + *Depth * Ray->Direction.y;
  1418. X
  1419. X         if ((Triangle->P2.x - s)*(Triangle->P2.y - Triangle->P1.y) <
  1420. X             (Triangle->P2.y - t)*(Triangle->P2.x - Triangle->P1.x))
  1421. X            if ((int) Triangle->Inverted) {
  1422. X               Ray_Triangle_Tests_Succeeded++;
  1423. X               return (TRUE);
  1424. X               }
  1425. X            else
  1426. X               return (FALSE);
  1427. X
  1428. X         if ((Triangle->P3.x - s)*(Triangle->P3.y - Triangle->P2.y) <
  1429. X             (Triangle->P3.y - t)*(Triangle->P3.x - Triangle->P2.x))
  1430. X            if ((int) Triangle->Inverted) {
  1431. X               Ray_Triangle_Tests_Succeeded++;
  1432. X               return (TRUE);
  1433. X               }
  1434. X            else
  1435. X               return (FALSE);
  1436. X
  1437. X         if ((Triangle->P1.x - s)*(Triangle->P1.y - Triangle->P3.y) <
  1438. X             (Triangle->P1.y - t)*(Triangle->P1.x - Triangle->P3.x))
  1439. X            if ((int) Triangle->Inverted) {
  1440. X               Ray_Triangle_Tests_Succeeded++;
  1441. X               return (TRUE);
  1442. X               }
  1443. X            else
  1444. X               return (FALSE);
  1445. X
  1446. X         if (!(int) Triangle->Inverted) {
  1447. X               Ray_Triangle_Tests_Succeeded++;
  1448. X               return (TRUE);
  1449. X               }
  1450. X            else
  1451. X               return (FALSE);
  1452. X
  1453. X      }
  1454. X   return (FALSE);
  1455. X   }
  1456. X
  1457. Xint Inside_Triangle (Point, Object)
  1458. X   VECTOR *Point;
  1459. X   OBJECT *Object;
  1460. X   {
  1461. X   return (FALSE);
  1462. X   }
  1463. X
  1464. Xvoid Triangle_Normal (Result, Object, Intersection_Point)
  1465. X   OBJECT *Object;
  1466. X   VECTOR *Result, *Intersection_Point;
  1467. X   {
  1468. X   TRIANGLE *Triangle = (TRIANGLE *) Object;
  1469. X
  1470. X   *Result = Triangle->Normal_Vector;
  1471. X   Perturb_Normal (Result, Triangle->Parent_Object,
  1472. X                   Intersection_Point, Result);
  1473. X   }
  1474. X
  1475. Xvoid *Copy_Triangle (Object)
  1476. X   OBJECT *Object;
  1477. X   {
  1478. X   TRIANGLE *New_Shape;
  1479. X
  1480. X   New_Shape = Get_Triangle_Shape ();
  1481. X   *New_Shape = * ((TRIANGLE *)Object);
  1482. X   New_Shape -> Next_Object = NULL;
  1483. X   return (New_Shape);
  1484. X   }
  1485. X
  1486. Xvoid Translate_Triangle (Object, Vector)
  1487. X   OBJECT *Object;
  1488. X   VECTOR *Vector;
  1489. X   {
  1490. X   TRIANGLE *Triangle = (TRIANGLE *) Object;
  1491. X   VECTOR Translation;
  1492. X
  1493. X   VEvaluate (Translation, Triangle->Normal_Vector, *Vector);
  1494. X   Triangle->Distance -= Translation.x + Translation.y + Translation.z;
  1495. X   VAdd (Triangle->P1, Triangle->P1, *Vector)
  1496. X   VAdd (Triangle->P2, Triangle->P2, *Vector)
  1497. X   VAdd (Triangle->P3, Triangle->P3, *Vector)
  1498. X   }
  1499. X
  1500. Xvoid Rotate_Triangle (Object, Vector)
  1501. X   OBJECT *Object;
  1502. X   VECTOR *Vector;
  1503. X   {
  1504. X   TRANSFORMATION Transformation;
  1505. X   TRIANGLE *Triangle = (TRIANGLE *) Object;
  1506. X
  1507. X   Get_Rotation_Transformation (&Transformation, Vector);
  1508. X   MTransformVector (&Triangle->Normal_Vector,
  1509. X                     &Triangle->Normal_Vector, &Transformation);
  1510. X   MTransformVector (&Triangle->P1, &Triangle->P1, &Transformation);
  1511. X   MTransformVector (&Triangle->P2, &Triangle->P2, &Transformation);
  1512. X   MTransformVector (&Triangle->P3, &Triangle->P3, &Transformation);
  1513. X   Compute_Triangle (Triangle);
  1514. X   }
  1515. X
  1516. Xvoid Scale_Triangle (Object, Vector)
  1517. X   OBJECT *Object;
  1518. X   VECTOR *Vector;
  1519. X   {
  1520. X   TRIANGLE *Triangle = (TRIANGLE *) Object;
  1521. X   DBL Length;
  1522. X
  1523. X   Triangle->Normal_Vector.x = Triangle->Normal_Vector.x / Vector->x;
  1524. X   Triangle->Normal_Vector.y = Triangle->Normal_Vector.y / Vector->y;
  1525. X   Triangle->Normal_Vector.z = Triangle->Normal_Vector.z / Vector->z;
  1526. X
  1527. X   VLength(Length, Triangle->Normal_Vector);
  1528. X   VScale (Triangle->Normal_Vector, Triangle->Normal_Vector, 1.0 / Length);
  1529. X   Triangle->Distance /= Length;
  1530. X
  1531. X   VEvaluate (Triangle->P1, Triangle->P1, *Vector);
  1532. X   VEvaluate (Triangle->P2, Triangle->P2, *Vector);
  1533. X   VEvaluate (Triangle->P3, Triangle->P3, *Vector);
  1534. X   }
  1535. X
  1536. X 
  1537. Xvoid Invert_Triangle (Object)
  1538. X   OBJECT *Object;
  1539. X   {
  1540. X   TRIANGLE *Triangle = (TRIANGLE  *) Object;
  1541. X
  1542. X   Triangle->Inverted ^= TRUE;
  1543. X   }
  1544. X
  1545. X/* Calculate the Phong-interpolated vector within the triangle
  1546. X   at the given intersection point. The math for this is a bit
  1547. X   bizarre:
  1548. X
  1549. X    -         P1
  1550. X    |        /|\ \
  1551. X    |       / |Perp\
  1552. X    |      /  V  \   \
  1553. X    |     /   |    \   \
  1554. X  u |    /____|_____PI___\
  1555. X    |   /     |       \    \
  1556. X    -  P2-----|--------|----P3
  1557. X              Pbase    PIntersect
  1558. X        |-------------------|
  1559. X                       v
  1560. X
  1561. X   Triangle->Perp is a unit vector from P1 to Pbase. We calculate
  1562. X
  1563. X   u = (PI - P1) DOT Perp / ((P3 - P1) DOT Perp).
  1564. X
  1565. X   We then calculate where the line from P1 to PI intersects the line P2 to P3:
  1566. X   PIntersect = (PI - P1)/u.
  1567. X
  1568. X   We really only need one coordinate of PIntersect.  We then calculate v as:
  1569. X
  1570. X      v = PIntersect.x / (P3.x - P2.x)
  1571. X or   v = PIntersect.y / (P3.y - P2.y)
  1572. X or   v = PIntersect.z / (P3.z - P2.z)
  1573. X
  1574. X   depending on which calculation will give us the best answers.
  1575. X
  1576. X   Once we have u and v, we can perform the normal interpolation as:
  1577. X
  1578. X     NTemp1 = N1 + u(N2 - N1);
  1579. X     NTemp2 = N1 + u(N3 - N1);
  1580. X     Result = normalize (NTemp1 + v(NTemp2 - NTemp1))
  1581. X
  1582. X   As always, any values which are constant for the triangle are cached
  1583. X   in the triangle.
  1584. X*/
  1585. X
  1586. Xvoid Smooth_Triangle_Normal (Result, Object, Intersection_Point)
  1587. X   OBJECT *Object;
  1588. X   VECTOR *Result, *Intersection_Point;
  1589. X   {
  1590. X   SMOOTH_TRIANGLE *Triangle = (SMOOTH_TRIANGLE *) Object;
  1591. X   VECTOR PIMinusP1, NTemp1, NTemp2;
  1592. X   DBL u, v;
  1593. X
  1594. X   VSub (PIMinusP1, *Intersection_Point, Triangle->P1);
  1595. X   VDot (u, PIMinusP1, Triangle->Perp);
  1596. X   if (u < 1.0e-9) {
  1597. X      *Result = Triangle->N1;
  1598. X      return;
  1599. X      }
  1600. X
  1601. X   /* BaseDelta contains P3.x-P2.x,  P3.y-P2.y, or P3.z-P2.z depending on the
  1602. X      value of vAxis. */
  1603. X
  1604. X   switch (Triangle->vAxis) {
  1605. X      case X_AXIS:  v = (PIMinusP1.x/u + Triangle->P1.x - Triangle->P2.x) / Triangle->BaseDelta;
  1606. X               break;
  1607. X
  1608. X      case Y_AXIS:  v = (PIMinusP1.y/u + Triangle->P1.y - Triangle->P2.y) / Triangle->BaseDelta;
  1609. X               break;
  1610. X
  1611. X      case Z_AXIS:  v = (PIMinusP1.z/u + Triangle->P1.z - Triangle->P2.z)/ Triangle->BaseDelta;
  1612. X               break;
  1613. X      }
  1614. X
  1615. X   VScale (NTemp1, Triangle->DN12, u);
  1616. X   VAdd (NTemp1, NTemp1, Triangle->N1);
  1617. X   VScale (NTemp2, Triangle->DN13, u);
  1618. X   VAdd (NTemp2, NTemp2, Triangle->N1);
  1619. X   VSub (*Result, NTemp2, NTemp1);
  1620. X   VScale (*Result, *Result, v);
  1621. X   VAdd (*Result, *Result, NTemp1); 
  1622. X   VNormalize (*Result, *Result);
  1623. X   Perturb_Normal (Result, Triangle->Parent_Object,
  1624. X                   Intersection_Point, Result);
  1625. X   }
  1626. X
  1627. Xvoid *Copy_Smooth_Triangle (Object)
  1628. X   OBJECT *Object;
  1629. X   {
  1630. X   SMOOTH_TRIANGLE *New_Shape;
  1631. X
  1632. X   New_Shape = Get_Smooth_Triangle_Shape ();
  1633. X   *New_Shape = * ((SMOOTH_TRIANGLE *)Object);
  1634. X   New_Shape -> Next_Object = NULL;
  1635. X   return (New_Shape);
  1636. X   }
  1637. X
  1638. Xvoid Rotate_Smooth_Triangle (Object, Vector)
  1639. X   OBJECT *Object;
  1640. X   VECTOR *Vector;
  1641. X   {
  1642. X   TRANSFORMATION Transformation;
  1643. X   SMOOTH_TRIANGLE *Triangle = (SMOOTH_TRIANGLE *) Object;
  1644. X
  1645. X   Get_Rotation_Transformation (&Transformation, Vector);
  1646. X   MTransformVector (&Triangle->Normal_Vector,
  1647. X                     &Triangle->Normal_Vector, &Transformation);
  1648. X   MTransformVector (&Triangle->P1, &Triangle->P1, &Transformation);
  1649. X   MTransformVector (&Triangle->P2, &Triangle->P2, &Transformation);
  1650. X   MTransformVector (&Triangle->P3, &Triangle->P3, &Transformation);
  1651. X   MTransformVector (&Triangle->N1, &Triangle->N1, &Transformation);
  1652. X   MTransformVector (&Triangle->DN12, &Triangle->DN12, &Transformation);
  1653. X   MTransformVector (&Triangle->DN13, &Triangle->DN13, &Transformation);
  1654. X   Compute_Triangle ((TRIANGLE *) Triangle);
  1655. X   }
  1656. END_OF_FILE
  1657. if test 17931 -ne `wc -c <'src/triangle.c'`; then
  1658.     echo shar: \"'src/triangle.c'\" unpacked with wrong size!
  1659. fi
  1660. # end of 'src/triangle.c'
  1661. fi
  1662. echo shar: End of archive 6 \(of 10\).
  1663. cp /dev/null ark6isdone
  1664. MISSING=""
  1665. for I in 1 2 3 4 5 6 7 8 9 10 ; do
  1666.     if test ! -f ark${I}isdone ; then
  1667.     MISSING="${MISSING} ${I}"
  1668.     fi
  1669. done
  1670. if test "${MISSING}" = "" ; then
  1671.     echo You have unpacked all 10 archives.
  1672.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  1673. else
  1674.     echo You still need to unpack the following archives:
  1675.     echo "        " ${MISSING}
  1676. fi
  1677. ##  End of shell archive.
  1678. exit 0
  1679. -- 
  1680. Mail submissions (sources or binaries) to <amiga@uunet.uu.net>.
  1681. Mail comments to the moderator at <amiga-request@uunet.uu.net>.
  1682. Post requests for sources, and general discussion to comp.sys.amiga.
  1683.